{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "35c11065",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7dd61743",
   "metadata": {},
   "source": [
    "学习材料: https://github.com/datawhalechina/fun-rec/blob/master/docs/%E7%AC%AC%E4%B8%80%E7%AB%A0%20%E6%8E%A8%E8%8D%90%E7%B3%BB%E7%BB%9F%E5%9F%BA%E7%A1%80/1.1%20%E5%9F%BA%E7%A1%80%E6%8E%A8%E8%8D%90%E7%AE%97%E6%B3%95/1.1.2%20%E5%8D%8F%E5%90%8C%E8%BF%87%E6%BB%A4.md"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5c86850",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# 概要"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14daecdc",
   "metadata": {
    "hidden": true
   },
   "source": [
    "协同过滤（Collaborative Filtering）推荐算法是最经典、最常用的推荐算法。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6494caf9",
   "metadata": {
    "hidden": true
   },
   "source": [
    "所谓协同过滤， 基本思想是**根据用户之前的喜好以及其他兴趣相近的用户的选择来给用户推荐物品**(基于对用户历史行为数据的挖掘发现用户的喜好偏向， 并预测用户可能喜好的产品进行推荐)，**一般是仅仅基于用户的行为数据（评价、购买、下载等）, 而不依赖于项的任何附加信息（物品自身特征）或者用户的任何附加信息（年龄， 性别等）**。目前应用比较广泛的协同过滤算法是基于邻域的方法， 而这种方法主要有下面两种算法：\n",
    "- 基于用户的协同过滤算法(UserCF): 给用户推荐和他兴趣相似的其他用户喜欢的产品\n",
    "- 基于物品的协同过滤算法(ItemCF): 给用户推荐和他之前喜欢的物品相似的物品\n",
    "\n",
    "不管是UserCF还是ItemCF算法， 非常重要的步骤之一就是计算用户和用户或者物品和物品之间的**相似度**， 所以下面先整理常用的相似性度量方法， 然后再对每个算法的具体细节进行展开。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0de08daf",
   "metadata": {},
   "source": [
    "# 相似性度量方法"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "415ec1ca",
   "metadata": {},
   "source": [
    "## 杰卡德(Jaccard)相似系数\n",
    "这个是衡量两个集合的相似度一种指标。两个用户$u$和$v$交互商品交集的数量占这两个用户交互商品并集的数量的比例，称为两个集合的杰卡德相似系数，用符号$sim_{uv}$表示，其中$N(u),N(v)$分别表示用户$u$和用户$v$交互商品的集合。 $$ sim_{uv}=\\frac{|N(u) \\cap N(v)|}{\\sqrt{|N(u)| \\cup|N(v)|}} $$ 由于杰卡德相似系数一般无法反映具体用户的评分喜好信息， 所以常用来评估用户是否会对某商品进行打分， 而不是预估用户会对某商品打多少分。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e722d5c",
   "metadata": {},
   "source": [
    "## 余弦相似度\n",
    "余弦相似度衡量了两个向量的夹角，夹角越小越相似。首先从集合的角度描述余弦相似度，相比于Jaccard公式来说就是分母有差异，不是两个用户交互商品的并集的数量，而是两个用户分别交互的商品数量的乘积，公式如下： $$ sim_{uv}=\\frac{|N(u) \\cap N(v)|}{\\sqrt{|N(u)|\\cdot|N(v)|}} $$ 从向量的角度进行描述，令矩阵$A$为用户-商品交互矩阵(因为是TopN推荐并不需要用户对物品的评分，只需要知道用户对商品是否有交互就行)，即矩阵的每一行表示一个用户对所有商品的交互情况，有交互的商品值为1没有交互的商品值为0，矩阵的列表示所有商品。若用户和商品数量分别为$m,n$的话，交互矩阵$A$就是一个$m$行$n$列的矩阵。此时用户的相似度可以表示为(其中$u\\cdot v$指的是向量点积)： $$ sim_{uv} = cos(u,v) =\\frac{u\\cdot v}{|u|\\cdot |v|} $$ 上述用户-商品交互矩阵在现实情况下是非常的稀疏了，为了避免存储这么大的稀疏矩阵，在计算用户相似度的时候一般会采用集合的方式进行计算。理论上向量之间的相似度计算公式都可以用来计算用户之间的相似度，但是会根据实际的情况选择不同的用户相似度度量方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c48de47",
   "metadata": {},
   "source": [
    "这个在具体实现的时候， 可以使用cosine_similarity进行实现："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "163cfd89",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 0.81649658],\n",
       "       [0.81649658, 1.        ]])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "i = [1, 0, 0, 0]\n",
    "j = [1, 0.5, 0.5, 0]\n",
    "cosine_similarity([i, j])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7547ae17",
   "metadata": {},
   "source": [
    "## 皮尔逊相关系数\n",
    "\n",
    "皮尔逊相关系数的公式与余弦相似度的计算公式非常的类似，首先对于上述的余弦相似度的计算公式写成求和的形式,其中$r_{ui},r_{vi}$分别表示用户$u$和用户$v$对商品$i$是否有交互(或者具体的评分值)： $$ sim_{uv} = \\frac{\\sum_i r_{ui}*r_{vi}}{\\sqrt{\\sum_i r_{ui}^2}\\sqrt{\\sum_i r_{vi}^2}} $$ 如下是皮尔逊相关系数计算公式，其中$r_{ui},r_{vi}$分别表示用户$u$和用户$v$对商品$i$是否有交互(或者具体的评分值)，$\\bar r_u, \\bar r_v$分别表示用户$u$和用户$v$交互的所有商品交互数量或者具体评分的平均值。 $$ sim(u,v)=\\frac{\\sum_{i\\in I}(r_{ui}-\\bar r_u)(r_{vi}-\\bar r_v)}{\\sqrt{\\sum_{i\\in I }(r_{ui}-\\bar r_u)^2}\\sqrt{\\sum_{i\\in I }(r_{vi}-\\bar r_v)^2}} $$ 所以相比余弦相似度，皮尔逊相关系数通过使用用户的平均分对各独立评分进行修正，减小了用户评分偏置的影响。具体实现， 我们也是可以调包， 这个计算方式很多， 下面是其中的一种："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9738d30e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.816496580927726, 0.18350341907227397)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from scipy.stats import pearsonr\n",
    "\n",
    "i = [1, 0, 0, 0]\n",
    "j = [1, 0.5, 0.5, 0]\n",
    "pearsonr(i, j)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "521206c2",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# 基于用户的协同过滤"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e802a41",
   "metadata": {
    "hidden": true
   },
   "source": [
    "基于用户的协同过滤（以下用UserCF表示），思想其实比较简单，**当一个用户A需要个性化推荐的时候， 我们可以先找到和他有相似兴趣的其他用户， 然后把那些用户喜欢的， 而用户A没有听说过的物品推荐给A。**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f936e76",
   "metadata": {
    "hidden": true
   },
   "source": [
    "![avatar](笔记图片/基于用户的协同过滤.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b47ed733",
   "metadata": {
    "hidden": true
   },
   "source": [
    "UserCF算法主要包括两个步骤：\n",
    "\n",
    "1. 找到和目标用户兴趣相似的集合\n",
    "2. 找到这个集合中的用户喜欢的， 且目标用户没有听说过的物品推荐给目标用户。\n",
    "\n",
    "上面的两个步骤中， 第一个步骤里面， 我们会基于前面给出的相似性度量的方法找出与目标用户兴趣相似的用户， 而第二个步骤里面， 如何基于相似用户喜欢的物品来对目标用户进行推荐呢？ 这个要依赖于目标用户对相似用户喜欢的物品的一个喜好程度， 那么如何衡量这个程度大小呢？ 为了更好理解上面的两个步骤， 下面拿一个具体的例子把两个步骤具体化。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "789b6f01",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**以下图为例，此例将会用于本文各种算法中**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75fcbdda",
   "metadata": {
    "hidden": true
   },
   "source": [
    "![avatar](笔记图片/UserCF表.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b9312c9",
   "metadata": {
    "hidden": true
   },
   "source": [
    "给用户推荐物品的过程可以形象化为一个**猜测用户对商品进行打分的任务**，上面表格里面是5个用户对于5件物品的一个打分情况，就可以理解为用户对物品的喜欢程度\n",
    "\n",
    "应用UserCF算法的两个步骤：\n",
    "\n",
    "1. 首先根据前面的这些打分情况(或者说已有的用户向量）计算一下Alice和用户1， 2， 3， 4的相似程度， 找出与Alice最相似的n个用户\n",
    "2. 根据这n个用户对物品5的评分情况和与Alice的相似程度会猜测出Alice对物品5的评分， 如果评分比较高的话， 就把物品5推荐给用户Alice， 否则不推荐。\n",
    "\n",
    "关于第一个步骤， 上面已经给出了计算两个用户相似性的方法， 这里不再过多赘述， 这里主要解决第二个问题， 如何产生最终结果的预测。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac40f42b",
   "metadata": {
    "hidden": true
   },
   "source": [
    "## 预测打分结果"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83c33e67",
   "metadata": {
    "hidden": true
   },
   "source": [
    "根据上面的几种方法， 我们可以计算出向量之间的相似程度， 也就是可以计算出Alice和其他用户的相近程度， 这时候我们就可以选出与Alice最相近的前n个用户， 基于他们对物品5的评价猜测出Alice的打分值， 那么是怎么计算的呢？"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78290c47",
   "metadata": {
    "hidden": true
   },
   "source": [
    "这里常用的方式之一是**利用用户相似度和相似用户的评价加权平均获得用户的评价预测**， 用下面式子表示："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "308d4c65",
   "metadata": {
    "hidden": true
   },
   "source": [
    "$$ R_{\\mathrm{u}, \\mathrm{p}}=\\frac{\\sum_{\\mathrm{s} \\in S}\\left(w_{\\mathrm{u}, \\mathrm{s}} \\cdot R_{\\mathrm{s}, \\mathrm{p}}\\right)}{\\sum_{\\mathrm{s} \\in S} w_{\\mathrm{u}, \\mathrm{s}}} $$ 这个式子里面， 权重$w_{u,s}$是用户$u$和用户$s$的相似度， $R_{s,p}$是用户$s$对物品$p$的评分。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4f88f0e",
   "metadata": {
    "hidden": true
   },
   "source": [
    "还有一种方式如下， 这种方式考虑的更加前面， 依然是用户相似度作为权值， 但后面不单纯的是其他用户对物品的评分， 而是**该物品的评分与此用户的所有评分的差值进行加权平均， 这时候考虑到了有的用户内心的评分标准不一的情况**， 即有的用户喜欢打高分， 有的用户喜欢打低分的情况"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78094a10",
   "metadata": {
    "hidden": true
   },
   "source": [
    "$$ P_{i, j}=\\bar{R}{i}+\\frac{\\sum{k=1}^{n}\\left(S_{i, k}\\left(R_{k, j}-\\bar{R}{k}\\right)\\right)}{\\sum{k=1}^{n} S_{i, k}} $$ 所以这一种计算方式更为推荐。下面的计算将使用这个方式。这里的$S_{i,k}$与上面的$w_{u,s}$的意思是类似的，表示的是用户i和用户k之间的相似度。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8c45477",
   "metadata": {
    "hidden": true
   },
   "source": [
    "在获得用户$u$对不同物品的评价预测后， 最终的推荐列表根据预测评分进行排序得到。 至此，基于用户的协同过滤算法的推荐过程完成。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73fe7213",
   "metadata": {
    "hidden": true
   },
   "source": [
    "## 案例说明"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a704c8bf",
   "metadata": {
    "hidden": true
   },
   "source": [
    "根据上面的问题， 下面手算一下：\n",
    "\n",
    "Aim: 猜测Alice对物品5的得分："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0a574d8",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**1. 计算Alice与其他用户的相似度（这里使用皮尔逊相关系数）**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a500394d",
   "metadata": {
    "hidden": true
   },
   "source": [
    "这里我们使用皮尔逊相关系数， 也就是Alice与用户1的相似度是0.85。同样的方式， 我们就可以计算与其他用户的相似度， 这里可以使用numpy的相似度函数得到用户的相似性矩阵\n",
    "\n",
    "最终Alice用户和用户2,用户3,用户4的相似度是0.82, 0.7, 0, -0.79。 所以如果n=2， 找到与Alice最相近的两个用户是用户1， 和Alice的相似度是0.85， 用户2， 和Alice相似度是0.7\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8002ff5",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**2. 根据相似度用户计算Alice对物品5的最终得分**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d986697",
   "metadata": {
    "hidden": true
   },
   "source": [
    "用户1对物品5的评分是3， 用户2对物品5的打分是5， 那么根据上面的计算公式， 可以计算出Alice对物品5的最终得分是 $$ P_{Alice, 物品5}=\\bar{R}{Alice}+\\frac{\\sum{k=1}^{2}\\left(S_{Alice,user k}\\left(R_{userk, 物品5}-\\bar{R}{userk}\\right)\\right)}{\\sum{k=1}^{2} S_{Alice, userk}}=4+\\frac{0.85*(3-2.4)+0.7*(5-3.8)}{0.85+0.7}=4.87 $$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5df2aa6b",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**3. 根据用户评分对用户进行推荐**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f51a9f5",
   "metadata": {
    "hidden": true
   },
   "source": [
    "这时候， 我们就得到了Alice对物品5的得分是4.87， 根据Alice的打分对物品排个序从大到小：$$物品1>物品5>物品3=物品4>物品2$$ 这时候，如果要向Alice推荐2款产品的话， 我们就可以推荐物品1和物品5给Alice\n",
    "\n",
    "至此， 基于用户的协同过滤算法原理介绍完毕。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4de8e524",
   "metadata": {
    "hidden": true
   },
   "source": [
    "## 编程实现"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2a27be7",
   "metadata": {
    "hidden": true
   },
   "source": [
    "这里简单的通过编程实现上面的案例，梳理一下上面的过程其实就是三步： 计算用户相似性矩阵、得到前n个相似用户、计算最终得分。\n",
    "\n",
    "所以我们下面的程序也是分为这三步："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5aeda926",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**1. 首先， 先把数据表给建立起来**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11887ebd",
   "metadata": {
    "hidden": true
   },
   "source": [
    " 这里我采用了字典的方式， 之所以没有用pandas， 是因为上面举得这个例子其实是个个例， 在真实情况中， 我们知道， 用户对物品的打分情况并不会这么完整， 会存在大量的空值， 所以矩阵会很稀疏， 这时候用DataFrame， 会有大量的NaN。故这里用字典的形式存储。 用两个字典， 第一个字典是物品-用户的评分映射， 键是物品1-5， 用A-E来表示， 每一个值又是一个字典， 表示的是每个用户对该物品的打分。 第二个字典是用户-物品的评分映射， 键是上面的五个用户， 用1-5表示， 值是该用户对每个物品的打分。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d1c5a2ba",
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# 定义数据集， 也就是那个表格， 注意这里我们采用字典存放数据， 因为实际情况中数据是非常稀疏的， 很少有情况是现在这样\n",
    "def loadData():\n",
    "    items={'A': {1: 5, 2: 3, 3: 4, 4: 3, 5: 1},\n",
    "           'B': {1: 3, 2: 1, 3: 3, 4: 3, 5: 5},\n",
    "           'C': {1: 4, 2: 2, 3: 4, 4: 1, 5: 5},\n",
    "           'D': {1: 4, 2: 3, 3: 3, 4: 5, 5: 2},\n",
    "           'E': {2: 3, 3: 5, 4: 4, 5: 1}\n",
    "          }\n",
    "    users={1: {'A': 5, 'B': 3, 'C': 4, 'D': 4},\n",
    "           2: {'A': 3, 'B': 1, 'C': 2, 'D': 3, 'E': 3},\n",
    "           3: {'A': 4, 'B': 3, 'C': 4, 'D': 3, 'E': 5},\n",
    "           4: {'A': 3, 'B': 3, 'C': 1, 'D': 5, 'E': 4},\n",
    "           5: {'A': 1, 'B': 5, 'C': 5, 'D': 2, 'E': 1}\n",
    "          }\n",
    "    return items,users\n",
    "\n",
    "items, users = loadData()\n",
    "item_df = pd.DataFrame(items).T\n",
    "user_df = pd.DataFrame(users).T"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a11c5d8a",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**2. 计算用户相似性矩阵**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62d62115",
   "metadata": {
    "hidden": true
   },
   "source": [
    "这个是一个共现矩阵, 5*5，行代表每个用户， 列代表每个用户， 值代表用户和用户的相关性，这里的思路是这样， 因为要求用户和用户两两的相关性， 所以需要用双层循环遍历用户-物品评分数据， 当不是同一个用户的时候， 我们要去遍历物品-用户评分数据， 在里面去找这两个用户同时对该物品评过分的数据放入到这两个用户向量中。 因为正常情况下会存在很多的NAN， 即可能用户并没有对某个物品进行评分过， 这样的不能当做用户向量的一部分， 没法计算相似性。 还是看代码吧， 感觉不太好描述："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a866f505",
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.852803</td>\n",
       "      <td>0.707107</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>-0.792118</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.852803</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.467707</td>\n",
       "      <td>0.489956</td>\n",
       "      <td>-0.900149</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.707107</td>\n",
       "      <td>0.467707</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>-0.161165</td>\n",
       "      <td>-0.466569</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.489956</td>\n",
       "      <td>-0.161165</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>-0.641503</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>-0.792118</td>\n",
       "      <td>-0.900149</td>\n",
       "      <td>-0.466569</td>\n",
       "      <td>-0.641503</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          1         2         3         4         5\n",
       "1  0.000000  0.852803  0.707107  0.000000 -0.792118\n",
       "2  0.852803  0.000000  0.467707  0.489956 -0.900149\n",
       "3  0.707107  0.467707  0.000000 -0.161165 -0.466569\n",
       "4  0.000000  0.489956 -0.161165  0.000000 -0.641503\n",
       "5 -0.792118 -0.900149 -0.466569 -0.641503  0.000000"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"计算用户相似性矩阵\"\"\"\n",
    "similarity_matrix = pd.DataFrame(np.zeros((len(users), len(users))), index=[1, 2, 3, 4, 5], columns=[1, 2, 3, 4, 5])\n",
    "\n",
    "# 遍历每条用户-物品评分数据\n",
    "for userID in users:\n",
    "    for otheruserId in users:\n",
    "        vec_user = []\n",
    "        vec_otheruser = []\n",
    "        if userID != otheruserId:\n",
    "            for itemId in items:   # 遍历物品-用户评分数据\n",
    "                itemRatings = items[itemId]        # 这也是个字典  每条数据为所有用户对当前物品的评分\n",
    "                if userID in itemRatings and otheruserId in itemRatings:  # 说明两个用户都对该物品评过分\n",
    "                    vec_user.append(itemRatings[userID])\n",
    "                    vec_otheruser.append(itemRatings[otheruserId])\n",
    "            # 这里可以获得相似性矩阵(共现矩阵)\n",
    "            similarity_matrix[userID][otheruserId] = np.corrcoef(np.array(vec_user), np.array(vec_otheruser))[0][1]\n",
    "            #similarity_matrix[userID][otheruserId] = cosine_similarity(np.array(vec_user), np.array(vec_otheruser))[0][1]\n",
    "similarity_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2444ebec",
   "metadata": {
    "hidden": true
   },
   "source": [
    "有了相似性矩阵， 我们就可以得到与Alice最相关的前n个用户。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e4a4a72",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**3.计算前n个相似的用户**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "30804a82",
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"计算前n个相似的用户\"\"\"\n",
    "n = 2\n",
    "similarity_users = similarity_matrix[1].sort_values(ascending=False)[:n].index.tolist()    # [2, 3]   也就是用户1和用户2\n",
    "similarity_users"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "429d911b",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**4.计算最终得分**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "d9085733",
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "用户Alice对物品5的打分:  4.871979899370592\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "      <th>E</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>4.87198</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>3.00000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.00000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>4.00000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>1.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.00000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     A    B    C    D        E\n",
       "1  5.0  3.0  4.0  4.0  4.87198\n",
       "2  3.0  1.0  2.0  3.0  3.00000\n",
       "3  4.0  3.0  4.0  3.0  5.00000\n",
       "4  3.0  3.0  1.0  5.0  4.00000\n",
       "5  1.0  5.0  5.0  2.0  1.00000"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"计算最终得分\"\"\"\n",
    "base_score = np.mean(np.array([value for value in users[1].values()]))\n",
    "weighted_scores = 0.\n",
    "corr_values_sum = 0.\n",
    "for user in similarity_users:  # [2, 3]\n",
    "    corr_value = similarity_matrix[1][user]            # 两个用户之间的相似性\n",
    "    mean_user_score = np.mean(np.array([value for value in users[user].values()]))    # 每个用户的打分平均值\n",
    "    weighted_scores += corr_value * (users[user]['E']-mean_user_score)      # 加权分数\n",
    "    corr_values_sum += corr_value\n",
    "final_scores = base_score + weighted_scores / corr_values_sum\n",
    "print('用户Alice对物品5的打分: ', final_scores)\n",
    "user_df.loc[1]['E'] = final_scores\n",
    "user_df\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "104301ab",
   "metadata": {
    "hidden": true
   },
   "source": [
    "至此， 我们就用代码完成了上面的小例子， 有了这个评分， 我们其实就可以对该用户做推荐了。 这其实就是微型版的UserCF的工作过程了。\n",
    "\n",
    "**注意：基于用户协同过滤的完整代码参考源代码文件中的UserCF.py**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cd6fc98",
   "metadata": {
    "hidden": true
   },
   "source": [
    "## UserCF优缺点"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce223c9d",
   "metadata": {
    "hidden": true
   },
   "source": [
    "User-based算法存在两个重大问题：\n",
    "\n",
    "1. 数据稀疏性。 一个大型的电子商务推荐系统一般有非常多的物品，用户可能买的其中不到1%的物品，不同用户之间买的物品重叠性较低，导致算法无法找到一个用户的邻居，即偏好相似的用户。这导致UserCF不适用于那些正反馈获取较困难的应用场景(如酒店预订， 大件商品购买等低频应用)\n",
    "\n",
    "2. 算法扩展性。 基于用户的协同过滤需要维护用户相似度矩阵以便快速的找出Topn相似用户， 该矩阵的存储开销非常大，存储空间随着用户数量的增加而增加，不适合用户数据量大的情况使用。\n",
    "\n",
    "由于UserCF技术上的两点缺陷， 导致很多电商平台并没有采用这种算法， 而是采用了ItemCF算法实现最初的推荐系统。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c268295",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# 基于物品的协同过滤"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbf33883",
   "metadata": {
    "hidden": true
   },
   "source": [
    "基于物品的协同过滤(ItemCF)的基本思想是预先根据所有用户的历史偏好数据计算物品之间的相似性，然后把与用户喜欢的物品相类似的物品推荐给用户。比如物品a和c非常相似，因为喜欢a的用户同时也喜欢c，而用户A喜欢a，所以把c推荐给用户A。**ItemCF算法并不利用物品的内容属性计算物品之间的相似度， 主要通过分析用户的行为记录计算物品之间的相似度， 该算法认为， 物品a和物品c具有很大的相似度是因为喜欢物品a的用户大都喜欢物品c。**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c5bbd87",
   "metadata": {
    "hidden": true
   },
   "source": [
    "基于物品的协同过滤算法主要分为两步：\n",
    "\n",
    "- 计算物品之间的相似度\n",
    "- 根据物品的相似度和用户的历史行为给用户生成推荐列表（购买了该商品的用户也经常购买的其他商品）"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9ed0495",
   "metadata": {
    "hidden": true
   },
   "source": [
    "基于物品的协同过滤算法和基于用户的协同过滤算法很像， 所以我们这里直接还是拿上面Alice的那个例子来看。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f25ea446",
   "metadata": {
    "hidden": true
   },
   "source": [
    "如果想知道Alice对物品5打多少分， 基于物品的协同过滤算法会这么做：\n",
    "\n",
    "1. 首先计算一下物品5和物品1， 2， 3， 4之间的相似性(它们也是向量的形式， 每一列的值就是它们的向量表示， 因为ItemCF认为物品a和物品c具有很大的相似度是因为喜欢物品a的用户大都喜欢物品c， 所以就可以基于每个用户对该物品的打分或者说喜欢程度来向量化物品)\n",
    "2. 找出与物品5最相近的n个物品\n",
    "3. 根据Alice对最相近的n个物品的打分去计算对物品5的打分情况"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d685267",
   "metadata": {
    "hidden": true
   },
   "source": [
    "## 具体计算步骤"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45efef57",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**1.计算物品间的相似度**\n",
    "\n",
    "根据皮尔逊相关系数， 可以找到与物品5最相似的2个物品是item1和item4(n=2)， 下面基于上面的公式计算最终得分：\n",
    "\n",
    "$$ P_{Alice, 物品5}=\\bar{R}{物品5}+\\frac{\\sum{k=1}^{2}\\left(S_{物品5,物品 k}\\left(R_{Alice, 物品k}-\\bar{R}{物品k}\\right)\\right)}{\\sum{k=1}^{2} S_{物品k, 物品5}}=\\frac{13}{4}+\\frac{0.97*(5-3.2)+0.58*(4-3.4)}{0.97+0.58}=4.6 $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "b7975145",
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "      <th>E</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>A</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>-0.476731</td>\n",
       "      <td>-0.123091</td>\n",
       "      <td>0.532181</td>\n",
       "      <td>0.969458</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B</th>\n",
       "      <td>-0.476731</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.645497</td>\n",
       "      <td>-0.310087</td>\n",
       "      <td>-0.478091</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C</th>\n",
       "      <td>-0.123091</td>\n",
       "      <td>0.645497</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>-0.720577</td>\n",
       "      <td>-0.427618</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D</th>\n",
       "      <td>0.532181</td>\n",
       "      <td>-0.310087</td>\n",
       "      <td>-0.720577</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.581675</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>E</th>\n",
       "      <td>0.969458</td>\n",
       "      <td>-0.478091</td>\n",
       "      <td>-0.427618</td>\n",
       "      <td>0.581675</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          A         B         C         D         E\n",
       "A  1.000000 -0.476731 -0.123091  0.532181  0.969458\n",
       "B -0.476731  1.000000  0.645497 -0.310087 -0.478091\n",
       "C -0.123091  0.645497  1.000000 -0.720577 -0.427618\n",
       "D  0.532181 -0.310087 -0.720577  1.000000  0.581675\n",
       "E  0.969458 -0.478091 -0.427618  0.581675  1.000000"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"计算物品的相似矩阵\"\"\"\n",
    "similarity_matrix = pd.DataFrame(np.ones((len(items), len(items))), index=['A', 'B', 'C', 'D', 'E'], columns=['A', 'B', 'C', 'D', 'E'])\n",
    "\n",
    "# 遍历每条物品-用户评分数据\n",
    "for itemId in items:\n",
    "    for otheritemId in items:\n",
    "        vec_item = []         # 定义列表， 保存当前两个物品的向量值\n",
    "        vec_otheritem = []\n",
    "        #userRagingPairCount = 0     # 两件物品均评过分的用户数\n",
    "        if itemId != otheritemId:    # 物品不同\n",
    "            for userId in users:    # 遍历用户-物品评分数据\n",
    "                userRatings = users[userId]    # 每条数据为该用户对所有物品的评分， 这也是个字典\n",
    "                \n",
    "                if itemId in userRatings and otheritemId in userRatings:   # 用户对这两个物品都评过分\n",
    "                    #userRagingPairCount += 1\n",
    "                    vec_item.append(userRatings[itemId])\n",
    "                    vec_otheritem.append(userRatings[otheritemId])\n",
    "            \n",
    "            # 这里可以获得相似性矩阵(共现矩阵)\n",
    "            similarity_matrix[itemId][otheritemId] = np.corrcoef(np.array(vec_item), np.array(vec_otheritem))[0][1]\n",
    "            #similarity_matrix[itemId][otheritemId] = cosine_similarity(np.array(vec_item), np.array(vec_otheritem))[0][1]\n",
    "similarity_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c972a78",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**2.找到相似的前n个物品**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "bf903d52",
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'E'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-28-f02846301774>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     10\u001b[0m     \u001b[0mcorr_value\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msimilarity_matrix\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'E'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mitem\u001b[0m\u001b[1;33m]\u001b[0m            \u001b[1;31m# 两个物品之间的相似性\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     11\u001b[0m     \u001b[0mmean_item_score\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mvalue\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mvalue\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mitems\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mitem\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m    \u001b[1;31m# 每个物品的打分平均值\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 12\u001b[1;33m     \u001b[0mweighted_scores\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mcorr_value\u001b[0m \u001b[1;33m*\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0musers\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mitem\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0mmean_item_score\u001b[0m\u001b[1;33m)\u001b[0m      \u001b[1;31m# 加权分数\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     13\u001b[0m     \u001b[0mcorr_values_sum\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mcorr_value\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     14\u001b[0m \u001b[0mfinal_scores\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mbase_score\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mweighted_scores\u001b[0m \u001b[1;33m/\u001b[0m \u001b[0mcorr_values_sum\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyError\u001b[0m: 'E'"
     ]
    }
   ],
   "source": [
    "\"\"\"得到与物品5相似的前n个物品\"\"\"\n",
    "n = 2\n",
    "similarity_items = similarity_matrix['E'].sort_values(ascending=False)[:n].index.tolist()       # ['A', 'D']\n",
    "\n",
    "\"\"\"计算最终得分\"\"\"\n",
    "base_score = np.mean(np.array([value for value in items['E'].values()]))\n",
    "weighted_scores = 0.\n",
    "corr_values_sum = 0.\n",
    "for item in similarity_items:  # ['A', 'D']\n",
    "    corr_value = similarity_matrix['E'][item]            # 两个物品之间的相似性\n",
    "    mean_item_score = np.mean(np.array([value for value in items[item].values()]))    # 每个物品的打分平均值\n",
    "    weighted_scores += corr_value * (users[1][item]-mean_item_score)      # 加权分数\n",
    "    corr_values_sum += corr_value\n",
    "final_scores = base_score + weighted_scores / corr_values_sum\n",
    "print('用户Alice对物品5的打分: ', final_scores)\n",
    "user_df.loc[1]['E'] = final_scores\n",
    "user_df\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd7958ca",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**注意：基于商品的协同过滤算法的完整代码参考源代码文件中的ItemCF.py**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "898f669f",
   "metadata": {},
   "source": [
    "# 算法评估"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "181afe8c",
   "metadata": {},
   "source": [
    "由于UserCF和ItemCF结果评估部分是共性知识点， 所以在这里统一标识。 这里介绍评测指标："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aad300d4",
   "metadata": {},
   "source": [
    "**1.召回率**\n",
    "\n",
    "对用户u推荐N个物品记为$R(u)$, 令用户u在测试集上喜欢的物品集合为$T(u)$， 那么召回率定义为： $$ \\operatorname{Recall}=\\frac{\\sum_{u}|R(u) \\cap T(u)|}{\\sum_{u}|T(u)|} $$ 这个意思就是说， 在用户真实购买或者看过的影片里面， 我模型真正预测出了多少， 这个考察的是模型推荐的一个全面性。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0c75b03",
   "metadata": {},
   "source": [
    "**2.准确率**\n",
    "\n",
    "准确率定义为： $$ \\operatorname{Precision}=\\frac{\\sum_{u} \\mid R(u) \\cap T(u)|}{\\sum_{u}|R(u)|} $$ 这个意思再说， 在我推荐的所有物品中， 用户真正看的有多少， 这个考察的是我模型推荐的一个准确性。 为了提高准确率， 模型需要把非常有把握的才对用户进行推荐， 所以这时候就减少了推荐的数量， 而这往往就损失了全面性， 真正预测出来的会非常少，所以实际应用中应该综合考虑两者的平衡。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d7077ec",
   "metadata": {},
   "source": [
    "**3.覆盖率**\n",
    "\n",
    "覆盖率反映了推荐算法发掘长尾的能力， 覆盖率越高， 说明推荐算法越能将长尾中的物品推荐给用户。 $$ \\text { Coverage }=\\frac{\\left|\\bigcup_{u \\in U} R(u)\\right|}{|I|} $$\n",
    "\n",
    "该覆盖率表示最终的推荐列表中包含多大比例的物品。如果所有物品都被给推荐给至少一个用户， 那么覆盖率是100%。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89398f25",
   "metadata": {},
   "source": [
    "**4.新颖度** \n",
    "\n",
    "用推荐列表中物品的平均流行度度量推荐结果的新颖度。 如果推荐出的物品都很热门， 说明推荐的新颖度较低。 由于物品的流行度分布呈长尾分布， 所以为了流行度的平均值更加稳定， 在计算平均流行度时对每个物品的流行度取对数。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46044294",
   "metadata": {},
   "source": [
    "# 协同过滤算法的权重改进"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adb8df40",
   "metadata": {},
   "source": [
    "![avatar](笔记图片/权重改进.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a09e028d",
   "metadata": {},
   "source": [
    "- 基础算法 图1为最简单的计算物品相关度的公式， 分子为同时喜好itemi和itemj的用户数\n",
    "- 对热门物品的惩罚 图1存在一个问题， 如果 item-j 是很热门的商品，导致很多喜欢 item-i 的用户都喜欢 item-j，这时 $w_{ij}$ 就会非常大。同样，几乎所有的物品都和 item-j 的相关度非常高，这显然是不合理的。所以图2中分母通过引入 $N(j)$ 来对 item-j 的热度进行惩罚。如果物品很热门， 那么$N(j)$就会越大， 对应的权重就会变小。\n",
    "- 对热门物品的进一步惩罚 如果 item-j 极度热门，上面的算法还是不够的。举个例子，《Harry Potter》非常火，买任何一本书的人都会购买它，即使通过图2的方法对它进行了惩罚，但是《Harry Potter》仍然会获得很高的相似度。这就是推荐系统领域著名的 Harry Potter Problem。\n",
    "- 如果需要进一步对热门物品惩罚，可以继续修改公式为如图3所示，通过调节参数 $α$，$α $越大，惩罚力度越大，热门物品的相似度越低，整体结果的平均热门程度越低。\n",
    "- 对活跃用户的惩罚 同样的，Item-based CF 也需要考虑活跃用户（即一个活跃用户（专门做刷单）可能买了非常多的物品）的影响，活跃用户对物品相似度的贡献应该小于不活跃用户。图4为集合了该权重的算法。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68cac67f",
   "metadata": {},
   "source": [
    "# 协同过滤算法的问题分析"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4accf59",
   "metadata": {},
   "source": [
    "协同过滤算法存在的问题之一就是**泛化能力弱**， 即协同过滤无法将两个物品相似的信息推广到其他物品的相似性上。 导致的问题是**热门物品具有很强的头部效应， 容易跟大量物品产生相似， 而尾部物品由于特征向量稀疏， 导致很少被推荐。** 比如下面这个例子："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4635ca46",
   "metadata": {},
   "source": [
    "A, B, C, D是物品， 看右边的物品共现矩阵， 可以发现物品D与A、B、C的相似度比较大， 所以很有可能将D推荐给用过A、B、C的用户。 但是物品D与其他物品相似的原因是因为D是一件热门商品， 系统无法找出A、B、C之间相似性的原因是其特征太稀疏， 缺乏相似性计算的直接数据。 所以这就是协同过滤的天然缺陷：**推荐系统头部效应明显， 处理稀疏向量的能力弱。**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08b3a2aa",
   "metadata": {},
   "source": [
    "为了解决这个问题， 同时增加模型的泛化能力，2006年，**矩阵分解技术(Matrix Factorization,MF)**被提出， 该方法在协同过滤共现矩阵的基础上， 使用更稠密的隐向量表示用户和物品， 挖掘用户和物品的隐含兴趣和隐含特征， 在一定程度上弥补协同过滤模型处理稀疏矩阵能力不足的问题。 具体细节等后面整理， 这里先铺垫一下。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "600ec2bc",
   "metadata": {},
   "source": [
    "# 发散问题"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4c5b384",
   "metadata": {},
   "source": [
    "**1.什么时候使用UserCF，什么时候使用ItemCF？为什么？**\n",
    "\n",
    "1. UserCF 由于是基于用户相似度进行推荐， 所以具备更强的社交特性， 这样的特点非常适于用户少， 物品多， 时效性较强的场合， 比如新闻推荐场景， 因为新闻本身兴趣点分散， 相比用户对不同新闻的兴趣偏好， 新闻的及时性，热点性往往更加重要， 所以正好适用于发现热点，跟踪热点的趋势。 另外还具有推荐新信息的能力， 更有可能发现惊喜, 因为看的是人与人的相似性, 推出来的结果可能更有惊喜，可以发现用户潜在但自己尚未察觉的兴趣爱好。\n",
    "对于用户较少， 要求时效性较强的场合， 就可以考虑UserCF。\n",
    "2. ItemCF 这个更适用于兴趣变化较为稳定的应用， 更接近于个性化的推荐， 适合物品少，用户多，用户兴趣固定持久， 物品更新速度不是太快的场合， 比如推荐艺术品， 音乐， 电影。 下面是UserCF和ItemCF的优缺点对比： （来自项亮推荐系统实践）"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4d41a68",
   "metadata": {},
   "source": [
    "**2.协同过滤在计算上有什么缺点？有什么比较好的思路可以解决（缓解）？**\n",
    "\n",
    "较差的稀疏向量处理能力\n",
    "\n",
    "第一个问题就是泛化能力弱， 即协同过滤无法将两个物品相似的信息推广到其他物品的相似性上。 导致的问题是热门物品具有很强的头部效应， 容易跟大量物品产生相似， 而尾部物品由于特征向量稀疏， 导致很少被推荐。 比如下面这个例子：\n",
    "\n",
    "A, B, C, D是物品， 看右边的物品共现矩阵， 可以发现物品D与A、B、C的相似度比较大， 所以很有可能将D推荐给用过A、B、C的用户。 但是物品D与其他物品相似的原因是因为D是一件热门商品， 系统无法找出A、B、C之间相似性的原因是其特征太稀疏， 缺乏相似性计算的直接数据。 所以这就是协同过滤的天然缺陷：推荐系统头部效应明显， 处理稀疏向量的能力弱。\n",
    "\n",
    "为了解决这个问题， 同时增加模型的泛化能力，2006年，矩阵分解技术(Matrix Factorization,MF)被提出， 该方法在协同过滤共现矩阵的基础上， 使用更稠密的隐向量表示用户和物品， 挖掘用户和物品的隐含兴趣和隐含特征， 在一定程度上弥补协同过滤模型处理稀疏矩阵能力不足的问题。 具体细节等后面整理， 这里先铺垫一下。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0cb27293",
   "metadata": {},
   "source": [
    "**3.上面介绍的相似度计算方法有什么优劣之处？**\n",
    "\n",
    "cosine相似度还是比较常用的， 一般效果也不会太差， 但是对于评分数据不规范的时候， 也就是说， 存在有的用户喜欢打高分， 有的用户喜欢打低分情况的时候，有的用户喜欢乱打分的情况， 这时候consine相似度算出来的结果可能就不是那么准确了， 比如下面这种情况：\n",
    "\n",
    "这时候， 如果用余弦相似度进行计算， 会发现用户d和用户f比较相似， 而实际上， 如果看这个商品喜好的一个趋势的话， 其实d和e比较相近， 只不过e比较喜欢打低分， d比较喜欢打高分。 所以对于这种用户评分偏置的情况， 余弦相似度就不是那么好了， 可以考虑使用下面的皮尔逊相关系数。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a57e9a1",
   "metadata": {},
   "source": [
    "**4.协同过滤还存在其他什么缺陷？有什么比较好的思路可以解决（缓解）？**\n",
    "\n",
    "协同过滤的特点就是完全没有利用到物品本身或者是用户自身的属性， 仅仅利用了用户与物品的交互信息就可以实现推荐，比较简单高效， 但这也是它的一个短板所在， 由于无法有效的引入用户年龄， 性别，商品描述，商品分类，当前时间，地点等一系列用户特征、物品特征和上下文特征， 这就造成了有效信息的遗漏，不能充分利用其它特征数据。\n",
    "\n",
    "为了解决这个问题， 在推荐模型中引用更多的特征，推荐系统慢慢的从以协同过滤为核心到了以逻辑回归模型为核心， 提出了能够综合不同类型特征的机器学习模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7fb3edb8",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
